package cn.metona.utils;

/**
 * 将工具类声明为 final，以防止它被继承
 */
public final class StringUtils {

    // 私有构造方法，防止实例化
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    /**
     * 判断字符串是否为空或空白
     * @param str 参数
     * @return 布尔值
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 判断字符串是否为 null
     * @param str 参数
     * @return 布尔值
     */
    public static boolean isNull(String str) {
        return str == null;
    }

    public static boolean isNotNull(String str) {
        return !isNull(str);
    }

    /**
     * 去除字符串两端的空白字符
     * @param str 参数
     * @return 字符串
     */
    public static String trim(String str) {
        return str == null ? null : str.trim();
    }

    /**
     * 去除字符串中的所有空白字符
     * @param str 参数
     * @return 字符串
     */
    public static String trimAllWhitespace(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.replaceAll("\\s+", "");
    }

    /**
     * 判断字符串是否以指定前缀开头（忽略大小写）
     * @param str 参数
     * @param prefix 前缀
     * @return 布尔值
     */
    public static boolean startsWithIgnoreCase(String str, String prefix) {
        if (str == null || prefix == null) {
            return false;
        }
        return str.toLowerCase().startsWith(prefix.toLowerCase());
    }

    /**
     * 判断字符串是否以指定后缀结尾（忽略大小写）
     * @param str 参数
     * @param suffix 后缀
     * @return 布尔值
     */
    public static boolean endsWithIgnoreCase(String str, String suffix) {
        if (str == null || suffix == null) {
            return false;
        }
        return str.toLowerCase().endsWith(suffix.toLowerCase());
    }

    /**
     * 反转字符串
     * @param str 参数
     * @return 字符串
     */
    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }

    /**
     * 截取字符串
     * @param str 参数
     * @param start 开始位置
     * @param end 结束位置
     * @return 字符串
     */
    public static String substring(String str, int start, int end) {
        if (isEmpty(str)) {
            return str;
        }
        if (start < 0 || end > str.length() || start > end) {
            throw new IllegalArgumentException("Invalid start or end index");
        }
        return str.substring(start, end);
    }

    /**
     * 将字符串转换为驼峰命名
     * @param str 参数
     * @return 字符串
     */
    public static String toCamelCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder result = new StringBuilder();
        boolean nextUpper = false;
        for (int i = 0; i < str.length(); i++) {
            char currentChar = str.charAt(i);
            if (currentChar == '_' || currentChar == '-') {
                nextUpper = true;
            } else {
                if (nextUpper) {
                    result.append(Character.toUpperCase(currentChar));
                    nextUpper = false;
                } else {
                    result.append(currentChar);
                }
            }
        }
        return result.toString();
    }

    /**
     * 将驼峰命名转换为下划线命名
     * @param str 参数
     * @return 字符串
     */
    public static String toSnakeCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char currentChar = str.charAt(i);
            if (Character.isUpperCase(currentChar)) {
                result.append('_').append(Character.toLowerCase(currentChar));
            } else {
                result.append(currentChar);
            }
        }
        return result.toString();
    }

    /**
     * 统计字符串中某个字符的出现次数
     * @param str 参数
     * @param target 目标字符
     * @return 整数
     */
    public static int countOccurrences(String str, char target) {
        if (isEmpty(str)) {
            return 0;
        }
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == target) {
                count++;
            }
        }
        return count;
    }

    /**
     * 判断字符串是否为数字
     * @param str 参数
     * @return 布尔值
     */
    public static boolean isNumeric(String str) {
        if (isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符串是否为字母
     * @param str 参数
     * @return 布尔值
     */
    public static boolean isAlpha(String str) {
        if (isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isLetter(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符串是否为字母或数字
     * @param str 参数
     * @return 布尔值
     */
    public static boolean isAlphaNumeric(String str) {
        if (isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isLetterOrDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 将字符串数组拼接为单个字符串
     * @param array 字符串数组
     * @param delimiter 分隔符
     * @return 字符串
     */
    public static String join(String[] array, String delimiter) {
        if (array == null || array.length == 0) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < array.length; i++) {
            result.append(array[i]);
            if (i < array.length - 1) {
                result.append(delimiter);
            }
        }
        return result.toString();
    }

    /**
     * 将字符串按指定分隔符拆分为数组
     * @param str 字符串
     * @param delimiter 分隔符
     * @return 字符串数组
     */
    public static String[] split(String str, String delimiter) {
        if (isEmpty(str)) {
            return new String[0];
        }
        return str.split(delimiter);
    }

    /**
     * 将字符串首字母大写
     * @param str 字符串
     * @return 字符串
     */
    public static String capitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

    /**
     * 将字符串首字母小写
     * @param str 字符串
     * @return 字符串
     */
    public static String uncapitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.substring(0, 1).toLowerCase() + str.substring(1);
    }

    /**
     * 去除字符串中的 HTML 标签
     * @param str 字符串
     * @return 字符串
     */
    public static String stripHtmlTags(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.replaceAll("<[^>]+>", "");
    }

    /**
     * 判断字符串是否为回文
     * @param str 字符串
     * @return 布尔值
     */
    public static boolean isPalindrome(String str) {
        if (isEmpty(str)) {
            return false;
        }
        String reversed = reverse(str);
        return str.equals(reversed);
    }
}
